// VideoStreamHandler.cpp
// 视频流处理类的实现

#include "VideoStreamHandler.hh"
extern "C" {
#include "ringfifo.h"
}
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>

// 引入MediaUtil工具类（统一从项目根的包含路径引用）
#include "../service/Logger.hh"
#include "../service/RAIIHelpers.hh"

// 默认环形缓冲区大小（根据视频格式计算）
#define DEFAULT_RING_BUFFER_SIZE 2 * 1024 * 1024 // 2MB

// 创建新的视频流处理器
VideoStreamHandler* VideoStreamHandler::createNew(void* env, 
                                               const struct VideoConfig& config) {
    VideoStreamHandler* handler = new VideoStreamHandler(env, config);
    if (handler == NULL) {
        ErrorHandler::reportError(VideoErrorCode::PARAMETER_ERROR, "Failed to create VideoStreamHandler");
        return NULL;
    }
    
    // 初始化互斥锁和条件变量
    if (pthread_mutex_init(&handler->fMutex, NULL) != 0) {
        char errorMsg[128];
        snprintf(errorMsg, sizeof(errorMsg), "Failed to initialize mutex: %s", strerror(errno));
        ErrorHandler::reportError(VideoErrorCode::PARAMETER_ERROR, errorMsg);
        delete handler;
        return NULL;
    }
    
    if (pthread_cond_init(&handler->fCond, NULL) != 0) {
        char errorMsg[128];
        snprintf(errorMsg, sizeof(errorMsg), "Failed to initialize condition variable: %s", strerror(errno));
        ErrorHandler::reportError(VideoErrorCode::PARAMETER_ERROR, errorMsg);
        pthread_mutex_destroy(&handler->fMutex);
        delete handler;
        return NULL;
    }
    
    // 初始化参数集
    handler->fSPS = NULL;
    handler->fSPSSize = 0;
    handler->fPPS = NULL;
    handler->fPPSSize = 0;
    handler->fParameterSetsUpdated = false;
    
    return handler;
}

// 构造函数
VideoStreamHandler::VideoStreamHandler(void* env, 
                                     const struct VideoConfig& config)
    : fEnviron(env), fConfig(config) {
    fIsInitialized = false;
    fRingAllocated = false;
    fSPS = NULL;
    fSPSSize = 0;
    fPPS = NULL;
    fPPSSize = 0;
    fParameterSetsUpdated = false;
}

// 析构函数
VideoStreamHandler::~VideoStreamHandler() {
    // 释放环形缓冲区（如果是我们创建的）
    freeRingBuffer();
    
    // 释放参数集
    if (fSPS != NULL) {
        free(fSPS);
        fSPS = NULL;
    }
    if (fPPS != NULL) {
        free(fPPS);
        fPPS = NULL;
    }
    
    // 销毁互斥锁和条件变量
    pthread_mutex_destroy(&fMutex);
    pthread_cond_destroy(&fCond);
    
    ErrorHandler::logInfo("VideoStreamHandler destroyed");
}

// 初始化视频流处理器
bool VideoStreamHandler::initialize() {
    ThreadSafeUtils::ScopedLock lock(fMutex);
    
    if (fIsInitialized) {
        ErrorHandler::logInfo("Already initialized");
        return true;
    }
    
    // 初始化环形缓冲区
    if (!initRingBuffer()) {
        ErrorHandler::reportError(VideoErrorCode::BUFFER_OVERFLOW, "Failed to initialize ring buffer");
        return false;
    }
    
    fIsInitialized = true;
    ErrorHandler::logInfo("VideoStreamHandler initialized successfully");
    
    return true;
}

// 初始化环形缓冲区
bool VideoStreamHandler::initRingBuffer() {
    // 计算合适的缓冲区大小
    unsigned bufferSize = DEFAULT_RING_BUFFER_SIZE;
    
    // 根据视频格式和分辨率调整缓冲区大小
    // 简化计算：宽度 * 高度 * 3 * 帧率 * 2（预留足够空间）
    // 注意：必须确保所有参数都有效，否则使用默认值
    if (fConfig.width > 0 && fConfig.height > 0 && fConfig.frameRate > 0) {
        // 检查计算是否会溢出
        unsigned long long calculatedSize = (unsigned long long)fConfig.width * 
                                           (unsigned long long)fConfig.height * 
                                           3ULL * 
                                           (unsigned long long)fConfig.frameRate * 
                                           2ULL;
        
        // 确保计算值在合理范围内（最大 100MB）
        if (calculatedSize > bufferSize && calculatedSize <= 100 * 1024 * 1024) {
            bufferSize = (unsigned)calculatedSize;
        }
    }
    
    // 确保缓冲区大小合理（最小 1MB，最大 100MB）
    if (bufferSize < DEFAULT_RING_BUFFER_SIZE) {
        bufferSize = DEFAULT_RING_BUFFER_SIZE;
    }
    if (bufferSize > 100 * 1024 * 1024) {
        bufferSize = 100 * 1024 * 1024;  // 限制最大为 100MB
    }
    
    // 添加调试日志，输出实际传入的参数值
    char debugMsg[256];
    snprintf(debugMsg, sizeof(debugMsg), 
             "Initializing ring buffer: config(width=%d, height=%d, frameRate=%d), calculated size=%u", 
             fConfig.width, fConfig.height, fConfig.frameRate, bufferSize);
    ErrorHandler::logInfo(debugMsg);
    
    // 初始化环形缓冲区
    ringmalloc(bufferSize);
    
    // 验证 ringmalloc 是否成功
    // 注意：ringmalloc 内部会设置 g_ring_buffer_initialized 标志
    // 这里我们通过检查来确保初始化成功
    char logMsg[128];
    snprintf(logMsg, sizeof(logMsg), "Ring buffer initialized with size: %u", bufferSize);
    ErrorHandler::logInfo(logMsg);
    
    // 标记环形缓冲区已分配
    fRingAllocated = true;
    
    // 额外验证：确保 ringmalloc 成功分配了内存
    // 注意：这是一个防御性检查，ringmalloc 内部已经有完整的错误处理
    ErrorHandler::logInfo("Ring buffer allocation completed, ready for use");
    
    return true;
}

// 释放环形缓冲区
void VideoStreamHandler::freeRingBuffer() {
    if (fRingAllocated) {
        ringfree();
        fRingAllocated = false;
        ErrorHandler::logInfo("Ring buffer freed");
    }
}

// 已移除: start/stop/线程逻辑，当前项目未使用

// 已移除: 线程与处理逻辑

// 已移除: 内部处理与统计

// 已移除: 外部帧处理接口

// 已移除: 帧校验

// 通知有新的视频帧可用
void VideoStreamHandler::notifyNewFrameAvailable() {
    // 简化实现，使用ErrorHandler记录日志
    ErrorHandler::logInfo("New frame available");
}

// 已移除: 回调设置

// 更新SPS/PPS参数集（实现IMediaStreamHandler接口）
void VideoStreamHandler::updateParameterSets(const unsigned char* spsData, size_t spsSize,
                                              const unsigned char* ppsData, size_t ppsSize) {
    ThreadSafeUtils::ScopedLock lock(fMutex);
    
    // 更新SPS
    if (spsData && spsSize > 0) {
        if (fSPS != NULL) {
            free(fSPS);
        }
        fSPS = (unsigned char*)malloc(spsSize);
        if (fSPS == NULL) {
            ErrorHandler::reportError(VideoErrorCode::BUFFER_OVERFLOW, "Failed to allocate memory for SPS");
            return;
        }
        memcpy(fSPS, spsData, spsSize);
        fSPSSize = spsSize;
    }
    
    // 更新PPS
    if (ppsData && ppsSize > 0) {
        if (fPPS != NULL) {
            free(fPPS);
        }
        fPPS = (unsigned char*)malloc(ppsSize);
        if (fPPS == NULL) {
            ErrorHandler::reportError(VideoErrorCode::BUFFER_OVERFLOW, "Failed to allocate memory for PPS");
            if (fSPS != NULL) {
                free(fSPS);
                fSPS = NULL;
                fSPSSize = 0;
            }
            return;
        }
        memcpy(fPPS, ppsData, ppsSize);
        fPPSSize = ppsSize;
    }
    
    fParameterSetsUpdated = true;
    char logMsg[128];
    snprintf(logMsg, sizeof(logMsg), "Parameter sets updated: SPS=%zu bytes, PPS=%zu bytes", fSPSSize, fPPSSize);
    ErrorHandler::logInfo(logMsg);
}

// 已移除: 动态更新配置

// 已移除: 关键帧回调